/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package BackEnd;

import java.util.ArrayList;
import java.util.Date;
import BackEnd.Beans.*;
import BackEnd.Exceptions.ExistingUsernameException;
import java.sql.Time;

/**
 *
 * @author emmanuel
 */
public class WSUsers {

    /**
     * Service: Crear usuario
     * @param n nombre
     * @param a apellido
     * @param t telefono
     * @param nu nombre de usuario
     * @param c contrasenia
     * @param o ocupacion [Ocupacion]
     * @param des descripcion
     * @param p provincia [Provincia]
     * @param pa pais[Pais]
     * @param fn fecha de nacimiento
     * @param s sexo
     * @param m mail
     * @return Bean IUsuario con el usuario creado
     */
    //public Usuario crearUsuario(String n, String a, String t, String nu, String c, Ocupacion o, String des, Provincia p, Pais pa, Date fn, String s, String m)
    public void crearUsuario(UsuarioBean iu)
    {
        Usuario u = new Usuario();
        u.setNombre(iu.getNombre());

        u.setApellido(iu.getApellido());

        u.setDescripcion(iu.getDescripcion());

        u.setTelefono(iu.getTelefono());

        u.setNombreUsuario(iu.getNombreUsuario());

        u.setContrasenia(iu.getContrasenia());

        u.setFechaNacimiento(iu.getFechaNacimiento());

        u.setMail(iu.getMail());

        Ocupacion o = new Ocupacion();
        o.setId(iu.getOcupacion().getId());
        o.setNombre(iu.getOcupacion().getNombre());
        u.setOcupacion(o);

        Provincia pr = new Provincia();
        Pais pa = new Pais();
        pr.setId(iu.getProvincia().getId());
        pr.setNombre(iu.getProvincia().getNombre());
        pa.setId(iu.getProvincia().getPais().getId());
        pa.setNombre(iu.getProvincia().getPais().getNombre());
        pr.setPais(pa);
        u.setProvincia(pr);
        pa.setId(iu.getPais().getId());
        pa.setNombre(iu.getPais().getNombre());
        u.setPais(pa);

        u.setSexo(iu.getSexo());

        TipoUsuario tu = new TipoUsuario();
        tu.setNombre(iu.getTipoUsuario().getNombre());
        Permiso p = new Permiso();
        ArrayList<PermisoBean> lista = iu.getTipoUsuario().getPermisos();
        for(int i = 0 ; i <= lista.size();i++)
        {
            p.setId(lista.get(i).getId());
            p.setNombre(lista.get(i).getNombre());
            tu.agregarPermiso(p);
        }
        u.setTipoUsuario(tu);
        
        
        u.setFechaAlta(new Date());

        u.setAmigos(new ArrayList<Usuario>());

        u.setSesiones(new ArrayList<Sesion>());

        // Grabamos el nuevo usuario
        iu.setId(u.grabar());
    }

    public UsuarioBean loguearUsuario(String nombreUsuario,String contrasenia)
    {
        Usuario u = new Usuario();
        UsuarioBean iu = null;
        if(u.abrir(nombreUsuario,contrasenia))
        {
            iu = new UsuarioBean();

            iu.setNombre(u.getNombre());

            iu.setApellido(u.getApellido());

            iu.setDescripcion(u.getDescripcion());

            iu.setTelefono(u.getTelefono());

            iu.setNombreUsuario(u.getNombreUsuario());

            iu.setContrasenia(u.getContrasenia());

            iu.setFechaNacimiento(u.getFechaNacimiento());

            iu.setMail(u.getMail());

            OcupacionBean io = new OcupacionBean();
            io.setId(u.getOcupacion().getId());
            io.setNombre(u.getOcupacion().getNombre());
            iu.setOcupacion(io);

            ProvinciaBean ipr = new ProvinciaBean();
            PaisBean ipa = new PaisBean();
            ipr.setId(u.getProvincia().getId());
            ipr.setNombre(u.getProvincia().getNombre());
            ipa.setId(u.getProvincia().getPais().getId());
            ipa.setNombre(u.getProvincia().getPais().getNombre());
            ipr.setPais(ipa);
            iu.setProvincia(ipr);
            ipa.setId(iu.getPais().getId());
            ipa.setNombre(iu.getPais().getNombre());
            iu.setPais(ipa);

            iu.setSexo(u.getSexo());

            TipoUsuarioBean itu = new TipoUsuarioBean();
            itu.setNombre(u.getTipoUsuario().getNombre());
            PermisoBean ip = new PermisoBean();
            ArrayList<Permiso> lista = u.getTipoUsuario().getPermisos();
            for(int i = 0 ; i <= lista.size();i++)
            {
                ip.setId(lista.get(i).getId());
                ip.setNombre(lista.get(i).getNombre());
                itu.agregarPermiso(ip);
            }
            iu.setTipoUsuario(itu);


            iu.setFechaAlta(u.getFechaAlta());


            iu.setSesion(new SesionBean(new Date(), null, ""));

            // Grabamos el nuevo usuario
            iu.setId(u.getId());
        }
        return iu;
        
    }

    public ArrayList<UsuarioBean> obtenerAmigosUsuario(UsuarioBean iu)
    {
        Usuario u = new Usuario();
        u.abrir(iu.getId());

        ArrayList<Usuario> amigos = u.getAmigos();
        ArrayList<UsuarioBean> iamigos = new ArrayList<UsuarioBean>();
        UsuarioBean iamigo = new UsuarioBean();
        for(int i = 0 ; i <= amigos.size();i++)
        {
            iamigo.setId(amigos.get(i).getId());
            iamigo.setNombre(amigos.get(i).getNombre());
            iamigo.setApellido(amigos.get(i).getApellido());
            iamigo.setFechaNacimiento(iamigos.get(i).getFechaNacimiento());
            iamigo.setMail(iamigos.get(i).getMail());
            iamigos.add(iamigo);
        }
        return iamigos;

    }

    public boolean cerrarSesionUsuario(UsuarioBean iu, SesionBean sb,Date fechaSalida, String modoSalida)
    {
        Usuario u = new Usuario();
        u.abrir(iu.getId());
        Sesion s = new Sesion();
        s.setId((int)iu.getSesion().getId());
        s.setFechaInicio(sb.getFechaInicio());
        s.setHoraInicio((Time)sb.getFechaInicio());
        s.setFechaInicio(iu.getSesion().getFechaInicio());
        s.setFechaFin(fechaSalida);
        s.setModoSalida(modoSalida);
        return u.cerrarSesion(s);
    }

    /**
     * Service: obtenerDatosElectivosNuevoUsuario
     * @return Bean IDatosElectivosNuevoUsuario
     */
    public DatosElectivosNuevoUsuarioBean obtenerDatosElectivosNuevoUsuario()
    {
        ArrayList<Provincia> pr = Provincia.getAllProvince();
        ArrayList<ProvinciaBean> ipr = new ArrayList<ProvinciaBean>();
        ProvinciaBean ip = new ProvinciaBean();
        PaisBean ipa = new PaisBean();
        for(int i = 0; i<=pr.size();i++)
        {
            ip.setId(pr.get(i).getId());
            ip.setNombre(pr.get(i).getNombre());
            ipa.setId(ip.getPais().getId());
            ipa.setNombre(ip.getPais().getNombre());
            ip.setPais(ipa);
            ipr.add(ip);
        }
        ArrayList<Pais> paises = Pais.getAllCountries();
        ArrayList<PaisBean> ipaises = new ArrayList<PaisBean>();
        PaisBean ipais = new PaisBean();
        for(int i = 0; i<=paises.size();i++)
        {
            ipais.setId(paises.get(i).getId());
            ipais.setNombre(paises.get(i).getNombre());
            ipaises.add(ipais);
        }
        ArrayList<Ocupacion> ocups = Ocupacion.getAllJob();
        ArrayList<OcupacionBean> iocups = new ArrayList<OcupacionBean>();
        OcupacionBean iocup = new OcupacionBean();
        for(int i = 0; i<=ocups.size();i++)
        {
            iocup.setId(ocups.get(i).getId());
            iocup.setNombre(ocups.get(i).getNombre());
            iocups.add(iocup);
        }
        DatosElectivosNuevoUsuarioBean denu = new DatosElectivosNuevoUsuarioBean(ipr,ipaises,iocups);
        return denu;
    }

    private UsuarioBean getUsuarioBean(long id)
    {
        Usuario u = new Usuario();
        UsuarioBean ub = null;
        if(u.abrir(id))
        {
            ub = new UsuarioBean();

            ub.setNombre(u.getNombre());

            ub.setApellido(u.getApellido());

            ub.setDescripcion(u.getDescripcion());

            ub.setTelefono(u.getTelefono());

            ub.setNombreUsuario(u.getNombreUsuario());

            ub.setContrasenia(u.getContrasenia());

            ub.setFechaNacimiento(u.getFechaNacimiento());

            ub.setMail(u.getMail());

            OcupacionBean io = new OcupacionBean();
            io.setId(u.getOcupacion().getId());
            io.setNombre(u.getOcupacion().getNombre());
            ub.setOcupacion(io);

            ProvinciaBean ipr = new ProvinciaBean();
            PaisBean ipa = new PaisBean();
            ipr.setId(u.getProvincia().getId());
            ipr.setNombre(u.getProvincia().getNombre());
            ipa.setId(u.getProvincia().getPais().getId());
            ipa.setNombre(u.getProvincia().getPais().getNombre());
            ipr.setPais(ipa);
            ub.setProvincia(ipr);
            ipa.setId(ub.getPais().getId());
            ipa.setNombre(ub.getPais().getNombre());
            ub.setPais(ipa);

            ub.setSexo(u.getSexo());

            TipoUsuarioBean itu = new TipoUsuarioBean();
            itu.setNombre(u.getTipoUsuario().getNombre());
            PermisoBean ip = new PermisoBean();
            ArrayList<Permiso> lista = u.getTipoUsuario().getPermisos();
            for(int i = 0 ; i <= lista.size();i++)
            {
                ip.setId(lista.get(i).getId());
                ip.setNombre(lista.get(i).getNombre());
                itu.agregarPermiso(ip);
            }
            ub.setTipoUsuario(itu);

            ub.setFechaAlta(u.getFechaAlta());

            SesionBean isesion = new SesionBean();
            isesion.setFechaInicio(u.getSesiones().get((u.getSesiones().size())-1).getFechaInicio());
            isesion.setFechaFin(u.getSesiones().get((u.getSesiones().size())-1).getFechaFin());
            isesion.setModoSalida(u.getSesiones().get((u.getSesiones().size())-1).getModoSalida());
            ub.setSesion(isesion);

            // Grabamos el nuevo usuario
            ub.setId(u.getId());
        }
        return ub;
    }


    public boolean enviarMensajePrivado(MensajePrivadoBean msjPri)
    {
        Usuario remitente = new Usuario();
        Usuario destinatario = new Usuario();
        remitente.abrir(msjPri.getRemitente().getId());
        
        if(destinatario.abrir(msjPri.getDestinatario().getId()))
        {
            MensajePrivado mp = new MensajePrivado(remitente,destinatario,msjPri.getFechaEnvio(),msjPri.getMensaje(),true);
            remitente.enviarMensaje(mp);
            return true;
        }
        else
        {
            return false;
        }
    }

    
    public ArrayList<MensajePrivadoBean> leerMensajesPrivados(UsuarioBean iu){
        Usuario u = new Usuario();
        u.abrir(iu.getId());
        ArrayList<MensajePrivadoBean> imsjs= new ArrayList<MensajePrivadoBean>();
        MensajePrivadoBean imsj= new MensajePrivadoBean();
        ArrayList<MensajePrivado> msjs = u.getMensajesNuevos();
        UsuarioBean iremitente = null, idestinatario = null;
        for(int i = 0; i < msjs.size() ; i++)
        {
            idestinatario = this.getUsuarioBean(msjs.get(i).getDestinatario().getId());
            iremitente = this.getUsuarioBean(msjs.get(i).getRemitente().getId());

            imsj.setDestinatario(idestinatario);
            imsj.setRemitente(iremitente);
            imsj.setFechaEnvio(msjs.get(i).getFechaEnvio());
            imsj.setMensaje(msjs.get(i).getMensaje());
            imsjs.add(imsj);
        }
        return imsjs;
    }

    public boolean cambiarEstadoMensaje(MensajePrivadoBean imp,boolean iem)
    {
        MensajePrivado mp = new MensajePrivado();
        if(mp.abrir(imp.getId()))
        {
            mp.setEstado(iem);
            return true;
        }
        return false;
    }

    public boolean cambiarEstadoUsuario(UsuarioBean iu,EstadoUsuarioBean ieu)
    {
        Usuario u = new Usuario();
        EstadoUsuario eu = new EstadoUsuario();
        if(u.abrir(iu.getId())  && eu.abrir(ieu.getId()))
        {
            u.setEstadoUsuario(eu);
            return true;
        }
        return false;
    }

    public ArrayList<EstadoUsuarioBean> obtenerEstadosUsuario()
    {
        ArrayList<EstadoUsuario> eus = EstadoUsuario.getAllUserState();
        ArrayList<EstadoUsuarioBean> ieus = new ArrayList<EstadoUsuarioBean>();
        EstadoUsuarioBean ieu = new EstadoUsuarioBean();
        for(int i = 0; i<= eus.size();i++)
        {
            ieu.setId(eus.get(i).getId());
            ieu.setNombre(eus.get(i).getNombre());
            ieu.setDescripcion(eus.get(i).getDescripcion());
            ieus.add(ieu);
        }
        return ieus;
    }

    /**
     * Este servicio permite agregar un nuevo amigo al usuario "duenio"
     * @param duenio Es el propietario de la amistad
     * @param nuevoAmigo el usuario al que hacemos amigo del "duenio"
     * @return la nueva lista de amigos del usuario "duenio"
     */
    public ArrayList<UsuarioBean> agregarAmigoUsuario(UsuarioBean duenio, UsuarioBean nuevoAmigo)
    {
        Usuario u = new Usuario();
        Usuario ami = new Usuario();
        u.abrir(duenio.getId());
        ami.abrir(nuevoAmigo.getId());
        u.agregarAmigo(ami);
        return this.getAmigosUsuario(duenio);
    }

    /**
     * Servicio que permite obtener un ArraList de los amigos del usuario "ub"
     * @param ub Dueño de las amistades
     * @return Lista de amigos
     */
    public ArrayList<UsuarioBean> getAmigosUsuario(UsuarioBean ub)
    {
        Usuario u = new Usuario();
        u.abrir(ub.getId());
        ArrayList<Usuario> us = u.getAmigos();
        ArrayList<UsuarioBean> ubs = new ArrayList<UsuarioBean>();
        UsuarioBean aux = new UsuarioBean();
        for(int i = 0; i<= us.size(); i++)
        {
            aux = this.getUsuarioBean(us.get(i).getId());
            ubs.add(aux);
        }
        return ubs;
    }

    /**
     * Servicio que posibilita remover un amigo de la lista de amigos del usuario
     * "duenio"
     * @param duenio Es el propietario de la amistad
     * @param examigo El usuario que deja de ser amigo de "duenio"
     * @return retorna verdadero si lo logró quitar de la lista de amigos y
     * falso si no lo logró
     */
    public boolean removerAmigoUsuario(UsuarioBean duenio, UsuarioBean examigo)
    {
        Usuario u  = new Usuario();
        Usuario ex = new Usuario();
        u.abrir(duenio.getId());
        ex.abrir(examigo.getId());
        return u.removerAmigo(ex);
    }

    private PostBean getPostBean(long id){
        Post p= new Post();
        PostBean pb =  null;
        if(p.abrir(id))
        {
            pb = new PostBean();
            pb.setId(p.getId());
            pb.setContenido(p.getContenido());
            pb.setFechaBorrado(p.getFechaBorrado());
            pb.setFechaCreacion(p.getFechaCreacion());
            pb.setFechaModeracion(p.getFechaModeracion());
            pb.setModerador(this.getUsuarioBean(p.getModerador().getId()));
            pb.setMotivoModeracion(p.getMotivoModeracion());
            pb.setTitulo(p.getTitulo());
            ArrayList<ComentarioPostBean> cpbs = new ArrayList<ComentarioPostBean>();
            for(int i = 0; i<= p.getComentarios().size();i++)
            {
                cpbs.add(this.getComentarioPostBean(p.getComentarios().get(i).getId()));
            }
            ArrayList<CategoriaBean> cbs = new ArrayList<CategoriaBean>();
            for(int i = 0; i <= p.getCategorias().size(); i++)
            {
                cbs.add(this.getCategoriaBean(p.getCategorias().get(i).getId()));
            }
        }
        return pb;
    }

    private ComentarioPostBean getComentarioPostBean(long idCom)
    {
        ComentarioPost cp = new ComentarioPost();
        ComentarioPostBean cpb = null;
        if(cp.abrir(idCom))
        {
            cpb = new ComentarioPostBean();
            cpb.setContenido(cp.getContenido());
            cpb.setFechaCreacion(cp.getFechaCreacion());
            cpb.setFechaModeracion(cp.getFechaModeracion());
            cpb.setModerador(this.getUsuarioBean(cp.getModerador().getId()));
            cpb.setMotivoModeracion(cp.getMotivoModeracion());
            cpb.setTitulo(cp.getTitulo());
            cpb.setUsuario(this.getUsuarioBean(cp.getUsuario().getId()));
        }
        return cpb;
    }

    private CategoriaBean getCategoriaBean(long id)
    {
        Categoria c = new Categoria();
        CategoriaBean cb=null;
        if(c.abrir(id))
        {
            cb = new CategoriaBean();
            cb.setId(c.getId());
            cb.setNombre(c.getNombre());
        }
        return cb;
    }

    public ComentarioPostBean moderarComentarioPost(PostBean pb,ComentarioPostBean postb, UsuarioBean moderador, String motivoModeracion, Date fechaModeracion)
    {
        ComentarioPost cp= new ComentarioPost();
        cp.abrir(postb.getId());

        Usuario mod = new Usuario();
        mod.abrir(moderador.getId());

        cp.setModerador(mod);
        cp.setMotivoModeracion(motivoModeracion);
        cp.setFechaModeracion(fechaModeracion);

        cp.grabar();

        return this.getComentarioPostBean(postb.getId());
    }

    public PostBean moderarPost(PostBean postb, UsuarioBean moderador, String motivoModeracion, Date fechaModeracion)
    {
        Post p= new Post();
        p.abrir(postb.getId());

        Usuario mod = new Usuario();
        mod.abrir(moderador.getId());

        p.setModerador(mod);
        p.setMotivoModeracion(motivoModeracion);
        p.setFechaModeracion(fechaModeracion);

        p.grabar();

        return this.getPostBean(p.getId());
    }

    public boolean darBajaUsuario(UsuarioBean ub)
    {
        Usuario u = new Usuario();
        if(u.abrir(ub.getId()))
        {
            return u.darDeBaja(new Date());
        }
        return false;
    }


    public boolean agregarPermisoTipoUsuario(TipoUsuarioBean tub,PermisoBean pb)
    {
        boolean res = false;
        TipoUsuario tu = new TipoUsuario();
        Permiso p = new Permiso();
        if(tu.abrir(tub.getId()) && p.abrir(pb.getId()))
        {
            tub.agregarPermiso(pb);
            tu.agregarPermiso(p);
            tu.grabar();
            res = true;
        }
        return res;
    }

    public boolean quitarPermisoTipoUsuario(TipoUsuarioBean tub,PermisoBean pb)
    {
        boolean res = false;
        TipoUsuario tu = new TipoUsuario();
        Permiso p = new Permiso();
        if(tu.abrir(tub.getId()) && p.abrir(pb.getId()))
        {
            tub.quitarPermiso(pb);
            tu.quitarPermiso(p);
            tu.grabar();
            res = true;
        }
        return res;
    }

    public PostBean eliminarComentarioPost(PostBean pb,ComentarioPostBean cpb)
    {
        Post p = new Post();
        PostBean aux = null;
        ComentarioPost cp = new ComentarioPost();
        if(p.abrir(pb.getId()) && cp.abrir(cpb.getId()))
        {
            p.agregarComentario(cp);
            p.grabar();
            this.getPostBean(p.getId());
        }
        return aux;
    }

    /**
     * Servicio que permite borrar un mensaje privado. 
     * @param ub
     * @param mpb
     * @return La lista de los nuevos mensajes privados sin el mensaje que se deseaba borrar. 
     * Si no se logra borrar, retorna null.
     */
    public ArrayList<MensajePrivadoBean> borrarMensajePrivado(UsuarioBean ub, MensajePrivadoBean mpb)
    {
        Usuario u = new Usuario();
        ArrayList<MensajePrivadoBean> mpbs = null;
        MensajePrivado mp = new MensajePrivado();
        if(u.abrir(ub.getId()) && mp.abrir(mpb.getId()))
        {
            u.borrarMensajePrivado(mp);
            u.grabar();
            mpbs = this.leerMensajesPrivados(ub);
        }
        return mpbs;
    }

    /**
     * Servicio que permite resetear la clave. Si no se logra resetear, retorna un
     * string nulo
     * @param ub Usuario al que se le reseteará la contraseña
     * @return string con la contraseña
     */
    public String resetearClave(UsuarioBean ub)
    {
        Usuario u = new Usuario();
        String clave = null;
        if(u.abrir(ub.getId()))
        {
            clave = u.getNombreUsuario();
            u.setContrasenia(clave);
            u.grabar();
        }
        return clave;
    }

    public PostBean modificarPost(PostBean pb)
    {
        Post p = new Post();
        if(p.abrir(pb.getId()))
        {
            p.setId(pb.getId());
            p.setContenido(pb.getContenido());
            p.setFechaBorrado(pb.getFechaBorrado());
            p.setFechaCreacion(pb.getFechaCreacion());
            p.setFechaModeracion(pb.getFechaModeracion());
            Usuario moderador = new Usuario();
            if(!moderador.abrir(pb.getModerador().getId()))
                return null;
            p.setModerador(moderador);
            p.setMotivoModeracion(pb.getMotivoModeracion());
            p.setTitulo(pb.getTitulo());
            ArrayList<ComentarioPost> cps = new ArrayList<ComentarioPost>();
            ComentarioPost cp = new ComentarioPost();
            for(int i = 0; i<= pb.getComentarios().size();i++)
            {
                cp.setContenido(pb.getComentarios().get(i).getContenido());
                cp.setFechaCreacion(pb.getComentarios().get(i).getFechaCreacion());
                cp.setFechaModeracion(pb.getComentarios().get(i).getFechaModeracion());
                cp.setId(pb.getComentarios().get(i).getId());
                if(moderador.abrir(pb.getComentarios().get(i).getModerador().getId()))
                    return null;
                cp.setModerador(moderador);
                cp.setMotivoModeracion(pb.getComentarios().get(i).getMotivoModeracion());
                cp.setTitulo(pb.getComentarios().get(i).getTitulo());
                Usuario uxx = new Usuario();
                if(uxx.abrir(pb.getComentarios().get(i).getUsuario().getId()))
                    return null;
                cp.setUsuario(uxx);
                cps.add(cp);
            }
            ArrayList<CategoriaBean> cbs = new ArrayList<CategoriaBean>();
            Categoria c = new Categoria();
            for(int i = 0; i <= p.getCategorias().size(); i++)
            {
                c.setId(p.getCategorias().get(i).getId());
                c.setNombre(p.getCategorias().get(i).getNombre());
                cbs.add(this.getCategoriaBean(p.getCategorias().get(i).getId()));
            }
            p.grabar();
        }
        return this.getPostBean(p.getId());
    }

    public PostBean eliminarPost(Post pb)
    {
        Post p = new Post();
        PostBean aux = null;
        if(p.abrir(pb.getId()))
        {
            p.setFechaBorrado(new Date());
            p.grabar();
            aux = this.getPostBean(p.getId());
        }
        return aux;
    }


    /**
     * Servicio para cambio de datos de usuario
     * @param ub Usuario a modificar
     * @param apellido 
     * @param descripcion
     * @param fechaNacimiento
     * @param mail
     * @param nombre
     * @param nombreUsuario
     * @param ocupacion
     * @param provincia
     * @param pais
     * @param sexo
     * @param telefono
     * @return usuario modificado
     * @throws BackEnd.ExistingUsernameException
     */
    public UsuarioBean modificarDatosUsuario(UsuarioBean ub,
            String apellido,
            String descripcion,
            Date fechaNacimiento,
            String mail,
            String nombre,
            String nombreUsuario,
            OcupacionBean ocupacion,
            ProvinciaBean provincia,
            PaisBean pais,
            String sexo,
            String telefono)
            throws ExistingUsernameException
    {
        Usuario u = new Usuario();
        Ocupacion o = new Ocupacion();
        Provincia pr = new Provincia();
        Pais pa = new Pais();
        UsuarioBean aux = null;
        if(u.abrir(ub.getId()) && o.abrir(ocupacion.getId()) &&
            pr.abrir(provincia.getId()) && pa.abrir(pais.getId()))
        {
            u.setApellido(apellido);
            u.setDescripcion(descripcion);
            u.setFechaNacimiento(fechaNacimiento);
            u.setMail(mail);
            u.setNombre(nombre);
            this.cambiarNombreUsuario(ub, nombre);
            u.setOcupacion(o);
            u.setProvincia(pr);
            u.setPais(pa);
            u.setSexo(sexo);
            u.setTelefono(telefono);
            u.grabar();
            aux = this.getUsuarioBean(u.getId());
        }
        return aux;
    }

    /**
     * Servicio para la modificación del nombre de usuario
     * @param ub
     * @param username
     * @throws BackEnd.ExistingUsernameException
     */
    public void cambiarNombreUsuario(UsuarioBean ub,String username) throws ExistingUsernameException
    {
        Usuario u = new Usuario();
        UsuarioBean aux = null;
        if(!Usuario.validarNombreUsuario(username))
        {
            if(u.abrir(ub.getId()))
            {
                u.setNombreUsuario(username);
                u.grabar();
            }
        }
        else
        {
            throw new ExistingUsernameException();
        }
    }

    /**
     * Servicio que nos devuelve los usuarios registrados
     * @return lista de usuarios registrados
     */
    public ArrayList<UsuarioBean> obtenerListadoUsuariosRegistrados()
    {
        ArrayList<Usuario> usuarios = Usuario.getUsuariosRegistrados();
        ArrayList<UsuarioBean> usuariosb = new ArrayList<UsuarioBean>();
        UsuarioBean ub = null;
        for(int i = 0; i<= usuarios.size();i++)
        {
            ub = this.getUsuarioBean(usuarios.get(i).getId());
            usuariosb.add(ub);
        }
        return usuariosb;
    }
}
